जावास्क्रिप्ट कॉन्करंट इटरेटर्स: पॅरलल सिक्वेन्स प्रोसेसिंगला शक्ती देणे

वेब डेव्हलपमेंटच्या सतत बदलणाऱ्या जगात, कामगिरी आणि प्रतिसादक्षमता ऑप्टिमाइझ करणे अत्यंत महत्त्वाचे आहे. असिंक्रोनस प्रोग्रामिंग हे आधुनिक जावास्क्रिप्टचा आधारस्तंभ बनले आहे, ज्यामुळे ॲप्लिकेशन्सना मुख्य थ्रेड ब्लॉक न करता एकाच वेळी अनेक कामे हाताळता येतात. हा ब्लॉग पोस्ट जावास्क्रिप्टमधील कॉन्करंट इटरेटर्सच्या आकर्षक जगात डोकावतो, जे पॅरलल सिक्वेन्स प्रोसेसिंग साध्य करण्यासाठी आणि लक्षणीय कामगिरी वाढवण्यासाठी एक शक्तिशाली तंत्र आहे.

कॉन्करंट इटरेशनची गरज समजून घेणे

जावास्क्रिप्टमधील पारंपरिक इटरेटिव्ह पद्धती, विशेषतः ज्यांमध्ये I/O ऑपरेशन्स (नेटवर्क रिक्वेस्ट्स, फाइल रीड्स, डेटाबेस क्वेरीज) समाविष्ट असतात, त्या अनेकदा हळू असू शकतात आणि वापरकर्त्याचा अनुभव खराब करू शकतात. जेव्हा एखादा प्रोग्राम कामांचा क्रम एकामागून एक प्रक्रिया करतो, तेव्हा प्रत्येक काम पूर्ण झाल्यावरच पुढचे काम सुरू होते. यामुळे अडथळे निर्माण होऊ शकतात, विशेषतः वेळखाऊ ऑपरेशन्स हाताळताना. एखाद्या API मधून आणलेल्या मोठ्या डेटासेटवर प्रक्रिया करण्याची कल्पना करा: जर डेटासेटमधील प्रत्येक आयटमसाठी वेगळा API कॉल आवश्यक असेल, तर अनुक्रमिक दृष्टिकोनाला बराच वेळ लागू शकतो.

कॉन्करंट इटरेशन एकाच वेळी अनेक कामे समांतरपणे चालवण्याची परवानगी देऊन या समस्येवर उपाय पुरवते. यामुळे प्रक्रियेचा वेळ लक्षणीयरीत्या कमी होऊ शकतो आणि तुमच्या ॲप्लिकेशनची एकूण कार्यक्षमता सुधारू शकते. वेब ॲप्लिकेशन्सच्या संदर्भात हे विशेषतः महत्त्वाचे आहे, जिथे वापरकर्त्याच्या सकारात्मक अनुभवासाठी प्रतिसादक्षमता अत्यंत आवश्यक असते. एखाद्या सोशल मीडिया प्लॅटफॉर्मचा विचार करा जिथे वापरकर्त्याला त्यांचे फीड लोड करायचे आहे, किंवा ई-कॉमर्स साइट जिथे उत्पादनांचे तपशील मिळवायचे आहेत. कॉन्करंट इटरेशन स्ट्रॅटेजीज वापरकर्त्याच्या सामग्रीशी संवाद साधण्याचा वेग मोठ्या प्रमाणात सुधारू शकतात.

इटरेटर्स आणि असिंक्रोनस प्रोग्रामिंगची मूलतत्त्वे

कॉन्करंट इटरेटर्सचा शोध घेण्यापूर्वी, जावास्क्रिप्टमधील इटरेटर्स आणि असिंक्रोनस प्रोग्रामिंगच्या मूळ संकल्पनांचा आढावा घेऊया.

जावास्क्रिप्टमधील इटरेटर्स

इटरेटर एक ऑब्जेक्ट आहे जो एक क्रम परिभाषित करतो आणि त्याच्या घटकांमध्ये एका वेळी एक प्रवेश करण्याचा मार्ग प्रदान करतो. जावास्क्रिप्टमध्ये, इटरेटर्स `Symbol.iterator` चिन्हावर आधारित आहेत. जेव्हा एखाद्या ऑब्जेक्टमध्ये या चिन्हासह एक पद्धत असते, तेव्हा तो इटरेबल बनतो. ही पद्धत एक इटरेटर ऑब्जेक्ट परत करायला पाहिजे, ज्यामध्ये `next()` पद्धत असते.

            
const iterable = {
  [Symbol.iterator]() {
    let index = 0;
    return {
      next() {
        if (index < 3) {
          return { value: index++, done: false };
        } else {
          return { value: undefined, done: true };
        }
      },
    };
  },
};

for (const value of iterable) {
  console.log(value);
}
// Output: 0
//         1
//         2

            

              
                Copy
              
            
          

प्रॉमिसेस आणि `async/await` सह असिंक्रोनस प्रोग्रामिंग

असिंक्रोनस प्रोग्रामिंग जावास्क्रिप्ट कोडला मुख्य थ्रेड ब्लॉक न करता ऑपरेशन्स कार्यान्वित करण्याची परवानगी देते. प्रॉमिसेस आणि `async/await` सिंटॅक्स हे असिंक्रोनस जावास्क्रिप्टचे प्रमुख घटक आहेत.

• प्रॉमिसेस (Promises): असिंक्रोनस ऑपरेशनच्या अंतिम पूर्ततेचे (किंवा अपयशाचे) आणि त्याच्या परिणामी मूल्याचे प्रतिनिधित्व करतात. प्रॉमिसेसची तीन स्थिती असतात: प्रलंबित (pending), पूर्ण (fulfilled), आणि नाकारलेली (rejected).
• `async/await`: हे प्रॉमिसेसवर आधारित एक सिंटॅक्स आहे, जे असिंक्रोनस कोडला सिंक्रोनस कोडसारखे दिसण्यास आणि वाटण्यास मदत करते, ज्यामुळे वाचनीयता सुधारते. `async` कीवर्ड असिंक्रोनस फंक्शन घोषित करण्यासाठी वापरला जातो. `await` कीवर्ड `async` फंक्शनमध्ये प्रॉमिस पूर्ण होईपर्यंत किंवा नाकारल्या जाईपर्यंत अंमलबजावणी थांबवण्यासाठी वापरला जातो.

            
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

fetchData();

            

              
                Copy
              
            
          

कॉन्करंट इटरेटर्स लागू करणे: तंत्र आणि डावपेच

सध्या जावास्क्रिप्टमध्ये मूळ, सार्वत्रिकरित्या स्वीकारलेले "कॉन्करंट इटरेटर" मानक नाही. तथापि, आपण विविध तंत्रांचा वापर करून कॉन्करंट वर्तन लागू करू शकतो. या पद्धती `Promise.all`, `Promise.allSettled` सारख्या विद्यमान जावास्क्रिप्ट वैशिष्ट्यांचा किंवा वर्कर थ्रेड्स आणि इव्हेंट लूप्स सारख्या कॉन्करंसी प्रिमिटिव्ह ऑफर करणाऱ्या लायब्ररींचा वापर करून पॅरलल इटरेशन्स तयार करतात.

१. कॉन्करंट ऑपरेशन्ससाठी `Promise.all` चा वापर

`Promise.all` हे एक अंगभूत जावास्क्रिप्ट फंक्शन आहे जे प्रॉमिसेसची एक ॲरे घेते आणि ॲरेमधील सर्व प्रॉमिसेस पूर्ण झाल्यावर रिजॉल्व्ह होते, किंवा कोणत्याही एका प्रॉमिसने रिजेक्ट केल्यास ते रिजेक्ट होते. असिंक्रोनस ऑपरेशन्सची मालिका एकाच वेळी कार्यान्वित करण्यासाठी हे एक शक्तिशाली साधन असू शकते.

            
async function processDataConcurrently(dataArray) {
  const promises = dataArray.map(async (item) => {
    // Simulate an asynchronous operation (e.g., API call)
    return new Promise((resolve) => {
      setTimeout(() => {
        const processedItem = `Processed: ${item}`;
        resolve(processedItem);
      }, Math.random() * 1000); // Simulate varying processing times
    });
  });

  try {
    const results = await Promise.all(promises);
    console.log(results);
  } catch (error) {
    console.error('Error processing data:', error);
  }
}

const data = ['item1', 'item2', 'item3', 'item4', 'item5'];
processDataConcurrently(data);

            

              
                Copy
              
            
          

या उदाहरणात, `data` ॲरेमधील प्रत्येक आयटम `.map()` पद्धतीद्वारे एकाच वेळी प्रक्रिया केली जाते. `Promise.all()` पद्धत हे सुनिश्चित करते की पुढे जाण्यापूर्वी सर्व प्रॉमिसेस पूर्ण झाले आहेत. हा दृष्टिकोन फायदेशीर आहे जेव्हा ऑपरेशन्स एकमेकांवर अवलंबून न राहता स्वतंत्रपणे कार्यान्वित केल्या जाऊ शकतात. हे पॅटर्न कामांची संख्या वाढल्यास चांगले काम करते कारण आपण आता सिरीयल ब्लॉकिंग ऑपरेशनच्या अधीन नाही.

२. अधिक नियंत्रणासाठी `Promise.allSettled` चा वापर

`Promise.allSettled` ही `Promise.all` सारखीच दुसरी अंगभूत पद्धत आहे, परंतु ती अधिक नियंत्रण प्रदान करते आणि रिजेक्शन अधिक चांगल्या प्रकारे हाताळते. ती सर्व प्रदान केलेल्या प्रॉमिसेस पूर्ण होण्याची किंवा नाकारण्याची वाट पाहते, शॉर्ट-सर्किटिंग न करता. ती एक प्रॉमिस परत करते जी ऑब्जेक्ट्सच्या ॲरेमध्ये रिजॉल्व्ह होते, जिथे प्रत्येक ऑब्जेक्ट संबंधित प्रॉमिसच्या परिणामाचे वर्णन करते (एकतर पूर्ण किंवा नाकारलेले).

            
async function processDataConcurrentlyWithAllSettled(dataArray) {
  const promises = dataArray.map(async (item) => {
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        if (Math.random() < 0.2) {
          reject(`Error processing: ${item}`); // Simulate errors 20% of the time
        } else {
          resolve(`Processed: ${item}`);
        }
      }, Math.random() * 1000); // Simulate varying processing times
    });
  });

  const results = await Promise.allSettled(promises);
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`Success for ${dataArray[index]}: ${result.value}`);
    } else if (result.status === 'rejected') {
      console.error(`Error for ${dataArray[index]}: ${result.reason}`);
    }
  });
}

const data = ['item1', 'item2', 'item3', 'item4', 'item5'];
processDataConcurrentlyWithAllSettled(data);

            

              
                Copy
              
            
          

जेव्हा तुम्हाला संपूर्ण प्रक्रिया थांबवल्याशिवाय वैयक्तिक रिजेक्शन हाताळायचे असतील तेव्हा हा दृष्टिकोन फायदेशीर ठरतो. जेव्हा एका आयटमचे अपयश इतर आयटमच्या प्रक्रियेत अडथळा आणू नये तेव्हा हे विशेषतः उपयुक्त आहे.

३. सानुकूल कॉन्करंसी लिमिटर लागू करणे

ज्या परिस्थितीत तुम्हाला पॅरॅलिझमची पातळी नियंत्रित करायची आहे (सर्व्हरवर जास्त भार टाकणे किंवा संसाधनांच्या मर्यादा टाळण्यासाठी), सानुकूल कॉन्करंसी लिमिटर तयार करण्याचा विचार करा. हे तुम्हाला एकाच वेळी चालणाऱ्या रिक्वेस्ट्सची संख्या नियंत्रित करण्यास अनुमती देते.

            
class ConcurrencyLimiter {
  constructor(maxConcurrent) {
    this.maxConcurrent = maxConcurrent;
    this.running = 0;
    this.queue = [];
  }

  async run(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({
        task,
        resolve,
        reject,
      });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }
    const { task, resolve, reject } = this.queue.shift();
    this.running++;
    try {
      const result = await task();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.running--;
      this.processQueue();
    }
  }
}

async function fetchDataWithLimiter(url) {
  // Simulate fetching data from a server
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(`Data from ${url}`);
    }, Math.random() * 1000); // Simulate varying network latency
  });
}

async function processDataWithLimiter(urls, maxConcurrent) {
  const limiter = new ConcurrencyLimiter(maxConcurrent);
  const results = [];

  for (const url of urls) {
    const task = async () => await fetchDataWithLimiter(url);
    const result = await limiter.run(task);
    results.push(result);
  }
  console.log(results);
}

const urls = [
  'url1',
  'url2',
  'url3',
  'url4',
  'url5',
  'url6',
  'url7',
  'url8',
  'url9',
  'url10',
];

processDataWithLimiter(urls, 3); // Limiting to 3 concurrent requests

            

              
                Copy
              
            
          

हे उदाहरण एक सोपे `ConcurrencyLimiter` क्लास लागू करते. `run` पद्धत क्यूमध्ये कार्ये जोडते आणि कॉन्करंसी मर्यादा परवानगी देते तेव्हा त्यांची प्रक्रिया करते. हे संसाधनांच्या वापरावर अधिक सूक्ष्म नियंत्रण प्रदान करते.

४. वेब वर्कर्सचा वापर (Node.js)

वेब वर्कर्स (किंवा त्यांचे Node.js समकक्ष, वर्कर थ्रेड्स) जावास्क्रिप्ट कोडला वेगळ्या थ्रेडमध्ये चालवण्याचा एक मार्ग प्रदान करतात, ज्यामुळे खरी पॅरॅलिझम शक्य होते. हे विशेषतः CPU-केंद्रित कार्यांसाठी प्रभावी आहे. हे थेट इटरेटर नाही, परंतु इटरेटरची कार्ये एकाच वेळी प्रक्रिया करण्यासाठी वापरले जाऊ शकते

            
// --- main.js ---
const { Worker } = require('worker_threads');

async function processDataWithWorkers(data) {
  const results = [];

  for (const item of data) {
    const worker = new Worker('./worker.js', { workerData: { item } });
    results.push(
      new Promise((resolve, reject) => {
        worker.on('message', resolve);
        worker.on('error', reject);
        worker.on('exit', (code) => {
          if (code !== 0) reject(new Error(`Worker stopped with exit code ${code}`));
        });
      })
    );
  }

  const finalResults = await Promise.all(results);
  console.log(finalResults);
}

const data = ['item1', 'item2', 'item3'];
processDataWithWorkers(data);

// --- worker.js ---
const { workerData, parentPort } = require('worker_threads');

// Simulate CPU-intensive task
function heavyTask(item) {
  let result = 0;
  for (let i = 0; i < 100000000; i++) {
    result += i;
  }
  return `Processed: ${item} Result: ${result}`;
}

const processedItem = heavyTask(workerData.item);
parentPort.postMessage(processedItem);

            

              
                Copy
              
            
          

या सेटअपमध्ये, `main.js` प्रत्येक डेटा आयटमसाठी एक `Worker` इन्स्टन्स तयार करतो. प्रत्येक वर्कर `worker.js` स्क्रिप्टला वेगळ्या थ्रेडमध्ये चालवतो. `worker.js` एक संगणकीयदृष्ट्या गहन कार्य करतो आणि नंतर परिणाम `main.js` कडे परत पाठवतो. वर्कर थ्रेड्सचा वापर मुख्य थ्रेडला ब्लॉक करणे टाळतो, ज्यामुळे कार्यांची पॅरलल प्रोसेसिंग शक्य होते.

कॉन्करंट इटरेटर्सचे व्यावहारिक उपयोग

कॉन्करंट इटरेटर्सचे विविध क्षेत्रांमध्ये व्यापक उपयोग आहेत:

• वेब ॲप्लिकेशन्स: एकाधिक APIs मधून डेटा लोड करणे, समांतरपणे प्रतिमा मिळवणे, सामग्री प्रीफेच करणे. एका जटिल डॅशबोर्ड ॲप्लिकेशनची कल्पना करा ज्याला अनेक स्त्रोतांकडून मिळवलेला डेटा प्रदर्शित करायचा आहे. कॉन्करंसीचा वापर केल्याने डॅशबोर्ड अधिक प्रतिसादक्षम होईल आणि लोड होण्याचा वेळ कमी जाणवेल.
• Node.js बॅकएंड्स: मोठे डेटासेट प्रक्रिया करणे, अनेक डेटाबेस क्वेरीज एकाच वेळी हाताळणे, आणि पार्श्वभूमी कार्ये करणे. एका ई-कॉमर्स प्लॅटफॉर्मचा विचार करा जिथे तुम्हाला मोठ्या प्रमाणात ऑर्डर्सची प्रक्रिया करायची आहे. या समांतर प्रक्रियेमुळे एकूण पूर्ततेचा वेळ कमी होईल.
• डेटा प्रोसेसिंग पाइपलाइन्स: मोठ्या डेटा स्ट्रीम्सचे रूपांतरण आणि फिल्टरिंग करणे. डेटा इंजिनियर्स या तंत्रांचा वापर करून पाइपलाइन्सना डेटा प्रोसेसिंगच्या मागणीनुसार अधिक प्रतिसादक्षम बनवतात.
• वैज्ञानिक संगणन: संगणकीयदृष्ट्या गहन गणना समांतरपणे करणे. वैज्ञानिक सिम्युलेशन, मशीन लर्निंग मॉडेल प्रशिक्षण आणि डेटा विश्लेषण यांना अनेकदा कॉन्करंट इटरेटर्सचा फायदा होतो.

सर्वोत्तम पद्धती आणि विचार करण्यासारख्या गोष्टी

कॉन्करंट इटरेशन महत्त्वपूर्ण फायदे देत असले तरी, खालील सर्वोत्तम पद्धतींचा विचार करणे महत्त्वाचे आहे:

• संसाधन व्यवस्थापन: संसाधनांच्या वापराबाबत जागरूक रहा, विशेषतः वेब वर्कर्स किंवा सिस्टम संसाधने वापरणाऱ्या इतर तंत्रांचा वापर करताना. तुमच्या सिस्टमवर जास्त भार टाकणे टाळण्यासाठी कॉन्करंसीची पातळी नियंत्रित करा.
• त्रुटी हाताळणी (Error Handling): कॉन्करंट ऑपरेशन्समध्ये संभाव्य अपयश चांगल्या प्रकारे हाताळण्यासाठी मजबूत त्रुटी हाताळणी यंत्रणा लागू करा. `try...catch` ब्लॉक्स आणि एरर लॉगिंगचा वापर करा. अपयश व्यवस्थापित करण्यासाठी `Promise.allSettled` सारख्या तंत्रांचा वापर करा.
• सिंक्रोनायझेशन: जर कॉन्करंट कार्यांना सामायिक संसाधनांमध्ये प्रवेश करण्याची आवश्यकता असेल, तर रेस कंडिशन आणि डेटा करप्शन टाळण्यासाठी सिंक्रोनायझेशन यंत्रणा (उदा. म्यूटेक्स, सेमाफोर किंवा ॲटॉमिक ऑपरेशन्स) लागू करा. एकाच डेटाबेस किंवा सामायिक मेमरी स्थानांवर प्रवेश करण्याच्या परिस्थितीचा विचार करा.
• डीबगिंग: डीबगिंग कॉन्करंट कोड आव्हानात्मक असू शकते. अंमलबजावणीचा प्रवाह समजून घेण्यासाठी आणि संभाव्य समस्या ओळखण्यासाठी डीबगिंग साधने आणि लॉगिंग व ट्रेसिंग सारख्या धोरणांचा वापर करा.
• योग्य दृष्टिकोन निवडा: तुमच्या कार्यांचे स्वरूप, संसाधनांची मर्यादा आणि कामगिरीच्या आवश्यकतांवर आधारित योग्य कॉन्करंसी धोरण निवडा. संगणकीयदृष्ट्या गहन कार्यांसाठी, वेब वर्कर्स अनेकदा एक उत्तम पर्याय असतात. I/O-बाउंड ऑपरेशन्ससाठी, `Promise.all` किंवा कॉन्करंसी लिमिटर्स पुरेसे असू शकतात.
• अति-कॉन्करंसी टाळा: जास्त कॉन्करंसीमुळे कॉन्टेक्स्ट स्विचिंग ओव्हरहेडमुळे कामगिरीत घट होऊ शकते. सिस्टम संसाधनांचे निरीक्षण करा आणि त्यानुसार कॉन्करंसीची पातळी समायोजित करा.
• चाचणी (Testing): कॉन्करंट कोडची कसून चाचणी घ्या जेणेकरून तो विविध परिस्थितीत अपेक्षेप्रमाणे वागेल आणि एज केसेस योग्यरित्या हाताळेल. युनिट टेस्ट आणि इंटिग्रेशन टेस्टचा वापर करून सुरुवातीलाच बग ओळखून ते दूर करा.

मर्यादा आणि पर्याय

कॉन्करंट इटरेटर्स शक्तिशाली क्षमता प्रदान करत असले तरी, ते नेहमीच परिपूर्ण उपाय नसतात:

• गुंतागुंत: कॉन्करंट कोड लागू करणे आणि डीबग करणे अनुक्रमिक कोडपेक्षा अधिक गुंतागुंतीचे असू शकते, विशेषतः सामायिक संसाधने हाताळताना.
• ओव्हरहेड: कॉन्करंट कार्ये तयार करणे आणि व्यवस्थापित करण्याशी संबंधित एक अंतर्भूत ओव्हरहेड असतो (उदा. थ्रेड निर्मिती, कॉन्टेक्स्ट स्विचिंग), जो काहीवेळा कामगिरीतील वाढीला निष्प्रभ करू शकतो.
• पर्याय: ऑप्टिमाइझ्ड डेटा स्ट्रक्चर्स, कार्यक्षम अल्गोरिदम आणि कॅशिंग वापरण्यासारख्या पर्यायी दृष्टिकोनांचा विचार करा. काहीवेळा, काळजीपूर्वक डिझाइन केलेला सिंक्रोनस कोड खराब अंमलात आणलेल्या कॉन्करंट कोडपेक्षा चांगली कामगिरी करू शकतो.
• ब्राउझर सुसंगतता आणि वर्कर मर्यादा: वेब वर्कर्सना काही मर्यादा आहेत (उदा. थेट DOM प्रवेश नाही). Node.js वर्कर थ्रेड्स, जरी अधिक लवचिक असले तरी, संसाधन व्यवस्थापन आणि संप्रेषणाच्या बाबतीत त्यांच्या स्वतःच्या आव्हानांचा संच आहे.

निष्कर्ष

कॉन्करंट इटरेटर्स हे कोणत्याही आधुनिक जावास्क्रिप्ट डेव्हलपरच्या शस्त्रागारातील एक मौल्यवान साधन आहे. पॅरलल प्रोसेसिंगच्या तत्त्वांचा अवलंब करून, तुम्ही तुमच्या ॲप्लिकेशन्सची कामगिरी आणि प्रतिसादक्षमता लक्षणीयरीत्या वाढवू शकता. `Promise.all`, `Promise.allSettled`, सानुकूल कॉन्करंसी लिमिटर्स आणि वेब वर्कर्स सारखी तंत्रे कार्यक्षम पॅरलल सिक्वेन्स प्रोसेसिंगसाठी आवश्यक घटक प्रदान करतात. तुम्ही कॉन्करंसी धोरणे लागू करताना, साधक-बाधक गोष्टींचा काळजीपूर्वक विचार करा, सर्वोत्तम पद्धतींचे पालन करा आणि तुमच्या प्रोजेक्टच्या गरजेनुसार सर्वोत्तम दृष्टिकोन निवडा. कॉन्करंट इटरेटर्सची पूर्ण क्षमता अनलॉक करण्यासाठी आणि एक अखंड वापरकर्ता अनुभव देण्यासाठी नेहमी स्पष्ट कोड, मजबूत त्रुटी हाताळणी आणि काळजीपूर्वक चाचणीला प्राधान्य द्या.

या धोरणांची अंमलबजावणी करून, डेव्हलपर्स जलद, अधिक प्रतिसादक्षम आणि अधिक स्केलेबल ॲप्लिकेशन्स तयार करू शकतात जे जागतिक प्रेक्षकांच्या मागण्या पूर्ण करतात.